#include <iostream>
#include <cstdio>
#include <cstring>
#include <unistd.h>
#include <cstdlib>
#include <sys/wait.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <vector>

const int basesize = 1024;
const int envnums = 64;
const int argcnums = 64;

// 我的系统的环境变量
char *Genv[envnums];
char *Gargv[argcnums];
int Gargc;

// 全局的当前工作路径
char pwd[basesize];
char pwdenv[basesize+5];
char hostname[100];
// 最后一次运行的返回值
int lastcode = 0;

// 全局变量与重定向有关
#define NoneRedir 0
#define InputRedir 1
#define OutputRedir 2
#define AppendRedir 3

int Redir = NoneRedir;
char *FileName = nullptr;
#define Trim(pos)             \
    do                        \
    {                         \
        while (isspace(*pos)) \
            pos++;            \
    } while (0);

enum RedirError
{
    InReDirError = 1,
    OutReDirError = 2,
    AppReDirError = 3,
    FileNameError = 4
};
std::vector<int> PipePos; // 全局变量，存放管道的位置

void InitEnv()
{
    extern char **environ;
    int index = 0;
    while (environ[index])
    {
        Genv[index] = new char[strlen(environ[index]) + 1];
        strncpy(Genv[index], environ[index], strlen(environ[index]) + 1);
        index++;
    }
    Genv[index] = nullptr;
}

std::string GetPwd()
{
    if (nullptr == getcwd(pwd, sizeof(pwd)))
        return "None";
    snprintf(pwdenv, sizeof(pwdenv), "PWD=%s", pwd);
    putenv(pwdenv);
    return pwd;
}

std::string GetLastDir()
{
    std::string cur = GetPwd();
    if (cur == "" || cur == "None")
        return cur;
    size_t pos = cur.rfind("/");
    return cur.substr(pos + 1);
}

std::string GetHostName()
{
    gethostname(hostname,sizeof(hostname));
    return hostname==nullptr?"None":hostname;
}

std::string GetUserName()
{
    std::string name = getenv("USER");
    return name.empty() ? "None" : name;
}

std::string MakeCommandLine()
{
    // [yang@huawei-cloud myshell]$
    char command_line[basesize];
    snprintf(command_line, basesize, "[%s@%s %s]&", GetUserName().c_str(), GetHostName().c_str(), GetLastDir().c_str());
    return command_line;
}

void PrintCommandLine()
{
    printf("%s", MakeCommandLine().c_str());
    fflush(stdout);
}

bool GetCommandLine(char command_buffer[], int size)
{
    // 我们认为：我们要将用户输入的命令行，当做一个完整的字符串
    // "ls -a -l -n"

    char *result = fgets(command_buffer, size, stdin);

    //    printf("%p\n %p\n",result,command_buffer);

    if (!result)
    {
        return false;
    }
    command_buffer[strlen(command_buffer) - 1] = 0; // 将结尾的回车设为0
    if (strlen(command_buffer) == 0)
        return false;
    return true;
}

void ParseCommand(char command_buffer[])
{
    memset(Gargv, 0, sizeof(Gargv)); // 清空之前的代码痕迹
    Gargc = 0;

    //"ls -l -a -n"

    const char *const sep = " ";
    Gargv[Gargc++] = strtok(command_buffer, sep); // 将第一个空格前的值切给Gargv[0];

    // 将剩下的值依次切给Gargv, 这里=的含义是 将切完的Gargv的值转为bool 进行比较
    while ((bool)(Gargv[Gargc++] = strtok(nullptr, sep)))
        ;
    Gargc--;
}

void ResetCommandLine()
{
    memset(Gargv, 0, sizeof(Gargv));
    Gargc = 0;
    Redir = 0;
    FileName = nullptr;
}

void ParseRedir(char command_buffer[], int len)
{
    int end = len;
    while (end >= 0)
    {
        if (command_buffer[end] == '<')
        {
            Redir = InputRedir;
            command_buffer[end] = 0;
            FileName = &command_buffer[end] + 1;
            Trim(FileName); // 文件名去空格
            break;
        }
        else if (command_buffer[end] == '>')
        {
            if (command_buffer[end - 1] == '>')
            {
                Redir = AppendRedir;
                command_buffer[end - 1] = 0;
                command_buffer[end] = 0;
                FileName = &command_buffer[end] + 1;
                Trim(FileName);
                break;
            }
            else
            {
                Redir = OutputRedir;
                command_buffer[end] = 0;
                FileName = &command_buffer[end] + 1;
                Trim(FileName);
                break;
            }
        }
        else
            end--;
    }
}

void ParseCommandLine(char command_buffer[], int len)
{
    ResetCommandLine();
    ParseRedir(command_buffer, len);
    ParseCommand(command_buffer);
}

void DoRedir()
{
    if (Redir == NoneRedir)
        return;
    if (FileName == nullptr)
        exit(FileNameError);

    if (Redir == InputRedir)
    {
        int fd = open(FileName, O_RDONLY);
        if (fd < 0)
        {
            exit(InReDirError);
        }
        else
            dup2(fd, 0);
    }
    else if (Redir == OutputRedir)
    {
        int fd = open(FileName, O_CREAT | O_WRONLY | O_TRUNC, 0666);
        if (fd < 0)
            exit(OutReDirError);
        else
            dup2(fd, 1);
    }
    else if (Redir == AppendRedir)
    {
        int fd = open(FileName, O_CREAT | O_WRONLY | O_APPEND, 0666);
        if (fd < 0)
            exit(AppReDirError);
        else
            dup2(fd, 1);
    }
}
bool ExecuteCommand()
{
    // 让子进程执行
    pid_t id = fork();
    if (id < 0)
        return false;
    if (id == 0)
    {
        // 子进程部分
        // 重定向
        DoRedir();
        // 1.执行命令
        execvpe(Gargv[0], Gargv, Genv);
        // execve(Gargv[0],Gargv,Genv);
        // 2.退出  正常是不会返回的，如果执行了下面的就说明出错了，所以退出值为1
        exit(1);
    }
    int status = 0;
    pid_t rid = waitpid(id, &status, 0);
    if (rid > 0)
    {
        if (WIFEXITED(status))
        {
            lastcode = WEXITSTATUS(status);
        }
        else
        {
            lastcode = 100;
        }
        return true;
    }
    return false;
}

void AddEnv(const char *item)
{
    int index = 0;
    while (Genv[index])
    {
        index++;
    }
    Genv[index] = new char[strlen(item) + 1];
    strncpy(Genv[index], item, strlen(item) + 1);
    Genv[++index] = nullptr;
}

bool CheckAndExecBuilCommand()
{
    if (strcmp(Gargv[0], "cd") == 0)
    {
        if (Gargc == 2)
        {
            chdir(Gargv[1]);
            lastcode = 0;
        }
        else
        {
            lastcode = 1;
        }
        return true;
    }
    else if (strcmp(Gargv[0], "export") == 0)
    {
        // export 也是内建命令 因为子进程改变了，父进程不会改变
        if (Gargc == 2)
        {
            AddEnv(Gargv[1]);
            lastcode = 0;
        }
        else
        {
            lastcode = 1;
        }
        return true;
    }
    else if (strcmp(Gargv[0], "env") == 0)
    {
        for (int i = 0; Genv[i]; i++)
        {
            printf("%s\n", Genv[i]);
        }
        lastcode = 0;
        return true;
    }
    else if (strcmp(Gargv[0], "echo") == 0)
    {
        if (Gargc == 2)
        {
            // echo $
            // echo $PATH
            // echo hello
            if (Gargv[1][0] == '$')
            {
                if (Gargv[1][1] == '?')
                {
                    printf("%d\n", lastcode);
                    lastcode = 0;
                }
                else
                {
                    char *temp = &Gargv[1][1];
                    printf("%s\n", getenv(temp));
                    lastcode = 0;
                }
            }
            else
            {
                printf("%s\n", Gargv[1]);
                lastcode = 0;
            }
        }
        else
        {
            lastcode = 3;
        }
        return true;
    }
    return false;
}
void ParseAndExecCommand(char command_buffer[])
{
    ParseCommandLine(command_buffer, strlen(command_buffer)); // 3.分析命令
    if (!CheckAndExecBuilCommand())                           // 内建指令，因为shell有部分指令只能又自己调用，而这类指令我们称之为内建指,这里就是检查输入是否为内建指令
        ExecuteCommand();                                     // 4. 执行命令
}
int CheckPipe(char command_buffer[])
{
    PipePos.clear(); // 清空之前的管道位置
    PipePos.push_back(-1); // 管道位置初始化
    for (int i = 0; i < strlen(command_buffer); i++)
    {
        if (command_buffer[i] == '|')
        {
            PipePos.push_back(i);     // 记录管道位置
            command_buffer[i] = '\0'; // 将管道符号替换为空格，以便后续分割
        }
    }
    return PipePos.size(); // 返回管道的数量

}
void Execpipe(char command_buffer[])
{
    std::vector<int> child_id;
    std::vector<std::pair<int, int>> pipe_fd; // 管道的读写文件描述符
    // v[i].first: i号管道的读文件描述符
    // v[i].second: i号管道的写文件描述符
    for (int i = 0; i < PipePos.size() - 1; i++) // 创建sz个进程，sz-1个管道
    {
        int pipefd[2];
        pipe(pipefd);
        pid_t pid = fork();
        if (pid == 0) // 子进程
        {
            close(pipefd[0]); // 关闭读端
            int prev_fd_sz = pipe_fd.size();
            // 因为新开的子进程会继承父进程的文件描述符，而父进程的文件描述符是不关闭的，所以每一次新开子进程，都需要将前面的不符合的文件描述符关闭
            for (int j = 0; j < prev_fd_sz; j++)
            {
                if (j < prev_fd_sz - 1)
                {
                    close(pipe_fd[j].first); // 将前面的读端关闭，除了最近的一个管道
                }
                close(pipe_fd[j].second); // 将前面的写端关闭
            }
            dup2(pipefd[1], 1); // 将写端重定向到管道的写端
            if (!pipe_fd.empty())  dup2(pipe_fd.back().first, 0); // 将读端重定向到上一个管道的写端
            // 发送命令给子进程执行
            ParseAndExecCommand(command_buffer + PipePos[i] + 1); 
            // 这里 pos[0]=-1,作用也就在这里.
            exit(0);
        }
        else // 父进程
        {
            pipe_fd.push_back({pipefd[0],pipefd[1]});  // 父进程记录管道的读写文件描述符
            child_id.push_back(pid);

        }
    }
    // 最后一个子进程
    pid_t pid = fork();
    if (pid == 0) // 子进程
    {
        close(pipe_fd.back().second); // 关闭写端
        int prev_fd_sz = pipe_fd.size();
        for (int j = 0; j < prev_fd_sz; j++)
        {
            if (j < prev_fd_sz - 1)
            {
                close(pipe_fd[j].first); // 将前面的读端关闭，除了最近的一个管道
            }
            close(pipe_fd[j].second); // 将前面的写端关闭
        }
        dup2(pipe_fd.back().first, 0); // 将读端重定向到上一个管道的读端
        // 发送命令给子进程执行
        ParseAndExecCommand(command_buffer + PipePos.back() + 1);
        exit(0);
    }
    child_id.push_back(pid);
    //父进程关闭所有的读写端
    for(auto& e:pipe_fd)
    {
        close(e.first);
        close(e.second);
    }
    // 等待子进程结束
    for (int i = 0; i < child_id.size(); i++)
    {
        int status = 0;
        pid_t rid = waitpid(child_id[i], &status, 0);
        if (rid > 0)
        {
            if (WIFEXITED(status))
            {
                lastcode = WEXITSTATUS(status);
            }
            else
            {
                lastcode = 100;
            }
            if(lastcode!=0) printf("warning: last command is %d\n", lastcode);
            else printf("waitpid success\n");
        }
        
    }
}

int main()
{
    InitEnv();
    char command_buffer[basesize];

    while (true)
    {
        PrintCommandLine(); // 1. 命令行提示符
        // command_buffer -> output

        if (!GetCommandLine(command_buffer, basesize)) // 2.获取用户命令
        {
            continue;
        }
        int sz = CheckPipe(command_buffer); // 3.检查是否有管道

       // 4. 如果没有管道，则直接执行命令
        if (sz == 1)
            ParseAndExecCommand(command_buffer);
        // 5. 如果有管道，则创建子进程，并将命令分割为多个命令，然后创建多个子进程，并将命令发送给子进程执行
        else
            Execpipe(command_buffer);
    }
    return 0;
}
